package LeetCodeTest;

import LeetCodeTest.BFS.BFSSolution;

import java.util.ArrayList;
import java.util.List;

public class Easy
{
    public static void main(String[] args)
    {
        Solution solution = new Solution();
        BFSSolution bfsSolution = new BFSSolution();
        //给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
        //你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
        /**
        int[] nums = new int[]{1, 2, 3, 7, 8, 11, 15};
        int target = 10;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i; j < nums.length; j++) {
                if (nums[i] + nums[j] == target)
                {
                    System.out.println(i);
                    System.out.println(j);
                }
            }
        }
         */

        //给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
        /**
        Scanner sc = new Scanner(System.in);
        System.out.println("enter");
        long num = sc.nextInt();
        if ( num < 0)
        {
            long num1 = -num;
            int[] shuzu = new int[10];
            for (int i = 0; i < 0; i++) {

            }
        }else {

        }
         */
        /**
        class Solution {
            public int reverse(int x) {
                long rs = 0;
                while(x != 0){
                    rs = rs*10+x%10;
                    x /= 10;
                }
                return (rs<Integer.MIN_VALUE || rs>Integer.MAX_VALUE) ? 0:(int)rs;
            }
        }
         */

        //小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。
        // 他们一共进行三次这个游戏，请返回 小A 猜对了几次？
        /**
        int count = 0;
        for (int i = 0; i < 3; i++) {
            int num1 = new java.util.Random().nextInt(3) + 1;
            int num2 = new java.util.Random().nextInt(3) + 1;
            if (num1 == num2){
                count++;
            }
            System.out.println(num1 + " " + num2);
        }
        System.out.println(count);
        */

        //给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
        //J 中的字母不重复，J和S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。
//        String string = "aaaaa#";
//        string.contains("#");

        /**
         * 贪心
         * 在柠檬水摊上，每一杯柠檬水售价为5美元。顾客排队购买一杯柠檬水，每杯柠檬水5元，
         * 顾客会给5元，10元，20元的纸币，你需要判断能否给这些顾客找零。
         * 例：[5,5,10,20] true    [5,20]false
         * 0<bills.length<1000
         */
//        int[] bills = { 5, 10, 20};
//        System.out.println(solution.lemonadeChange1(bills));

        /**
         * 给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一棵高度最小的二叉搜索树。
         * 例：输入：[-10,-3,0,5,9] 输出：[0,-3,9,-10,null,5]
         */
//        int[] nums = {-10,-3,0,5,9};
//        solution.sortedArrayToBST(nums);

        /**
         * 1047 删除字符串中所有相邻重复项
         * 给出由小写字母组成的字符串S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
         * 在 S 上反复执行重复项删除操作，直到无法继续删除。
         * 在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
         *示例：
         * 输入："abbaca"
         * 输出："ca"
         * 解释：例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，
         * 这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，
         * 其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
         * 提示：
         * 1 <= S.length <= 20000
         * S 仅由小写英文字母组成。
         */
        String S = "abbaca";
        StringBuffer s = bfsSolution.removeDuplicates(S);
        System.out.println(s);

        /**
         * 559.N叉树的最大深度
         * 给定一个 N 叉树，找到其最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
         * N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔。
         * 输入：root = [1,null,3,2,4,null,5,6]
         * 输出：3
         * 输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
         * 输出：5
         */
    }
}

